<!DOCTYPE html>
<html lang="en-US">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<title>tuple_string [HALCON算子参考手册]</title>
<style type="text/css">
      body {
    color: #000000;
    background-color: #ffffff;
    margin: 0;
    font-family: Arial, Helvetica, sans-serif;
}

.body_main {
    margin-left: 35px;
    margin-right: 35px;
}

@media screen and (min-width:992px) {

    .body_main {
        margin-left: 10%;
        margin-right: 10%;
    }

    table.toctable {
        width: 80%
    }
}

@media screen and (min-width:1400px) {

    .body_main {
        margin-left: 15%;
        margin-right: 15%;
    }

    table.toctable {
        width: 70%
    }
}

body>div ul ul {
    margin-left: inherit;
}

a:link {
    color: #0044cc;
}

a:link,
a:visited {
    text-decoration: none;
}

a:link:hover,
a:visited:hover {
    text-decoration: underline;
}

th {
    text-align: left;
}

h1,
h2,
h3,
h4,
h5,
h6 {
    text-rendering: optimizeLegibility;
    color: #666666;
}

code {
    font-family: monospace,monospace;
}

h1 a.halconoperator {
    font-family: Arial, Helvetica, sans-serif;
    color: #666666;
}

h2 a.halconoperator {
    font-family: Arial, Helvetica, sans-serif;
    color: #666666;
}

hr {
    border: 0;
    border-top: solid 1px #f28d26;
}

.pre {
    display: block;
    padding-bottom: 1ex;
    font-family: monospace;
    white-space: pre;
}

pre {
    font-family: monospace, monospace;
    padding: 1ex;
    white-space: pre-wrap;
}

.toc {
    font-size: 80%;
    border-top: 1px dashed #f28d26;
    border-bottom: 1px dashed #f28d26;
    padding-top: 5px;
    padding-bottom: 5px;
}

.inv {
    margin: 0;
    border: 0;
    padding: 0;
}

.banner {
    color: #666666;
    padding-left: 1em;
}

.logo {
    background-color: white;
}

.keyboard {
    font-size: 80%;
    padding-left: 3px;
    padding-right: 3px;
    border-radius: 5px;
    border-width: 1px;
    border-style: solid;
    border-color: #f28d26;
    background-color: #f3f3f3;
}

.warning {
    margin-top: 2ex;
    margin-bottom: 1ex;
    padding: 10px;
    text-align: center;
    border: 1px solid;
    color: #bb0000;
    background-color: #fff7f7
}

.imprint {
    margin-top: 1ex;
    font-size: 80%;
    color: #666666;
}

.imprinthead {
    font-weight: bolder;
    color: #666666;
}

.indexlink {
    text-align: right;
    padding-bottom: 5px;
}

.postscript {
    margin-top: 2ex;
    font-size: 80%;
    color: #666666
}

.evenrow {
    background-color: #e7e7ef;
    vertical-align: top;
}

.oddrow {
    background-color: #f7f7ff;
    vertical-align: top;
}

.headrow {
    background-color: #97979f;
    color: #ffffff;
    vertical-align: top;
}

.logorow {
    vertical-align: top;
}

.error {
    color: red;
}

.var {
    font-style: italic
}

.halconoperator {
    font-family: monospace, monospace;
}

span.operator {
    font-family: monospace, monospace;
}

span.procedure {
    font-family: monospace, monospace;
}

span.operation {
    font-family: monospace, monospace;
}

span.feature {
    font-family: Arial, Helvetica, Homerton, sans-serif;
}

ul {
    padding-left: 1.2em;
}

li.dot {
    list-style-type: square;
    color: #f28d26;
}

.breadcrumb {
    font-size: 80%;
    color: white;
    background-color: #062d64;
    margin-bottom: 20px;
    padding-left: 35px;
    padding-right: 35px;
    padding-bottom: 15px;
}

.webbar {
    font-size: 80%;
    background-color: #dddddd;
    margin-top: 0px;
    margin-left: -35px;
    margin-right: -35px;
    margin-bottom: 0px;
    padding-top: 5px;
    padding-left: 35px;
    padding-right: 35px;
    padding-bottom: 5px;
}

.footer {
    display: flex;
    flex-wrap: wrap;
    justify-content: space-between;
    border-top: 1px dashed #f28d26;
    font-size: 80%;
    color: #666666;
    padding-bottom: 8px;
}

.footer .socialmedia a {
    padding-left: 7px;
}

.socialmedia {
    padding-top: 10px;
}

.copyright {
    margin-top: 19px;
}

.breadcrumb a {
    color: #ffffff;
    border-bottom: 1px solid white;
}

.breadcrumb a:link:hover,
.breadcrumb a:visited:hover {
    text-decoration: none;
    border-bottom: none;
}

.heading {
    margin-top: 1ex;
    font-size: 110%;
    font-weight: bold;
    color: #666666;
}

.text {
    color: black;
}

.example {
    font-size: 80%;
    background-color: #f3f3f3;
    border: 1px dashed #666666;
    padding: 10px;
}

.displaymath {
    display: block;
    text-align: center;
    margin-top: 1ex;
    margin-bottom: 1ex;
}

.title {
    float: left;
    padding-top: 3px;
    padding-bottom: 3px;
}

.signnote {
    font-family: Arial, Helvetica, Homerton, sans-serif;
    font-size: 80%;
    color: #666666;
    font-weight: lighter;
    font-style: italic
}

.par {
    margin-bottom: 1.5em;
}

.parhead {
    text-align: right;
}

.parname {
    float: left;
}

.pardesc {
    font-size: 85%;
    margin-top: 0.5em;
    margin-bottom: 0.5em;
    margin-left: 2em;
}

.parcat {
    color: #666;
    font-weight: bold;
}

*[data-if=cpp],
*[data-if=c],
*[data-if=dotnet],
*[data-if=com],
*[data-if=python] {
    display: none;
}

.tabbar {
    text-align: right;
    border-bottom: 1px solid #f28d26;
    margin-bottom: 0.5em;
}

ul.tabs {
    padding-top: 3px;
    padding-bottom: 3px;
    margin-top: 10px;
    margin-bottom: 0;
    font-size: 80%
}

ul.tabs li {
    padding-top: 3px;
    padding-bottom: 3px;
    display: inline;
    overflow: hidden;
    list-style-type: none;
    margin: 0;
    margin-left: 8px;
    border-top: 1px solid #666;
    border-left: 1px solid #666;
    border-right: 1px solid #666;
}

ul.tabs li.active {
    border-left: 1px solid #f28d26;
    border-right: 1px solid #f28d26;
    border-top: 1px solid #f28d26;
    border-bottom: 1px solid #fff;
}

ul.tabs li.inactive {
    background-color: #eee;
}

ul.tabs li a {
    padding-left: 5px;
    padding-right: 5px;
    color: #666;
}

ul.tabs li a:link:hover {
    text-decoration: none;
}

ul.tabs li.inactive a {
    color: #666;
}

ul.tabs li.active a {
    color: black;
}

dl.generic dd {
    margin-bottom: 1em;
}

.pari {
    color: olive;
}

.paro {
    color: maroon;
}

.comment {
    font-size: 80%;
    color: green;
    white-space: nowrap;
}

table.grid {
    border-collapse: collapse;
}

table.grid td {
    padding: 5px;
    border: 1px solid;
}

table.layout {
    border: 0px;
}

table.layout td {
    padding: 5px;
}

table.table {
    border-collapse: collapse;
}

table.table td {
    padding: 5px;
    border-left: 0px;
    border-right: 0px;
}

table.table tr:last-child {
    border-bottom: 1px solid;
}

table.table th {
    padding: 5px;
    border-top: 1px solid;
    border-bottom: 1px solid;
    border-left: 0px;
    border-right: 0px;
}

.details_summary {
    cursor: pointer;
}

table.toctable {
    width: 100%;
}

table.toctable col:first-child {
    width: 20%;
}

table.toctable col:nth-last-child(2) {
    width: 8%;
}

table.altcolored tr:nth-child(even) {
    background-color: #f3f3f3;
}

    </style>
<!--OP_REF_STYLE_END-->
<script>
    <!--
var active_lang='hdevelop';function switchVisibility(obj,active_lang,new_lang)
{var display_style='inline';
for(var i=0;i<obj.length;i++)
{if(obj.item(i).getAttribute('data-if')==new_lang)
{obj.item(i).style.display=display_style;}
if(obj.item(i).getAttribute('data-if')==active_lang)
{obj.item(i).style.display='none';}}
return;}
function toggleLanguage(new_lang,initial)
{if(active_lang!=new_lang)
{var lis=document.getElementsByTagName('li');for(var i=0;i<lis.length;i++)
{if(lis.item(i).id=='syn-'+new_lang)
{lis.item(i).className='active';}
else
{lis.item(i).className='inactive';}}
var divs=document.getElementsByTagName('div');var spans=document.getElementsByTagName('span');switchVisibility(divs,active_lang,new_lang);switchVisibility(spans,active_lang,new_lang);if(!initial)
{setCookie("halcon_reference_language",new_lang,null,null);}
active_lang=new_lang;}
return;}
function setCookie(name,value,domain,exp_offset,path,secure)
{localStorage.setItem(name,value);}
function getCookie(name)
{return localStorage.getItem(name);}
function initialize()
{var qs=location.href.split('?')[1];var qs_lang_raw=location.href.split('interface=')[1];var qs_lang;if(qs_lang_raw)
{qs_lang=qs_lang_raw.split('#')[0];}
var cookie_lang=getCookie("halcon_reference_language");var new_lang;if((qs_lang=="hdevelop")||(qs_lang=="dotnet")||(qs_lang=="python")||(qs_lang=="cpp")||(qs_lang=="c"))
{new_lang=qs_lang;setCookie("halcon_reference_language",new_lang,null,null);}
else if((cookie_lang=="hdevelop")||(cookie_lang=="dotnet")||(cookie_lang=="python")||(cookie_lang=="cpp")||(cookie_lang=="c"))
{new_lang=cookie_lang;}
else
{new_lang="hdevelop";}
toggleLanguage(new_lang,1);return;}
-->

  </script>
</head>
<body onload="initialize();">
<div class="breadcrumb">
<br class="inv"><a href="index.html">目录</a> / <a href="toc_tuple.html">Tuple</a> / <a href="toc_tuple_conversion.html">Conversion</a><br class="inv">
</div>
<div class="body_main">
<div class="tabbar"><ul class="tabs">
<li id="syn-hdevelop" class="active"><a href="javascript:void(0);" onclick="toggleLanguage('hdevelop')" onfocus="blur()">HDevelop</a></li>
<li id="syn-dotnet" class="inactive"><a href="javascript:void(0);" onclick="toggleLanguage('dotnet')" onfocus="blur()">.NET</a></li>
<li id="syn-python" class="inactive"><a href="javascript:void(0);" onclick="toggleLanguage('python')" onfocus="blur()">Python</a></li>
<li id="syn-cpp" class="inactive"><a href="javascript:void(0);" onclick="toggleLanguage('cpp')" onfocus="blur()">C++</a></li>
<li id="syn-c" class="inactive"><a href="javascript:void(0);" onclick="toggleLanguage('c')" onfocus="blur()">C</a></li>
</ul></div>
<div class="indexlink">
<a href="index_classes.html"><span data-if="dotnet" style="display:none;">类别</span><span data-if="cpp" style="display:none;">类别</span></a><span data-if="dotnet" style="display:none;"> | </span><span data-if="cpp" style="display:none;"> | </span><a href="index_by_name.html">算子列表</a>
</div>
<!--OP_REF_HEADER_END-->
<h1 id="sec_name">
<span data-if="hdevelop" style="display:inline;">tuple_string</span><span data-if="c" style="display:none;">tuple_string</span><span data-if="cpp" style="display:none;">TupleString</span><span data-if="dotnet" style="display:none;">TupleString</span><span data-if="python" style="display:none;">tuple_string</span> (算子名称)</h1>
<h2>名称</h2>
<p><code><span data-if="hdevelop" style="display:inline;">tuple_string</span><span data-if="c" style="display:none;">tuple_string</span><span data-if="cpp" style="display:none;">TupleString</span><span data-if="dotnet" style="display:none;">TupleString</span><span data-if="python" style="display:none;">tuple_string</span></code> — Convert a tuple into a tuple of strings.</p>
<h2 id="sec_synopsis">参数签名</h2>
<div data-if="hdevelop" style="display:inline;">
<p>
<code><b>tuple_string</b>( :  : <a href="#T"><i>T</i></a>, <a href="#Format"><i>Format</i></a> : <a href="#String"><i>String</i></a>)</code></p>
</div>
<div data-if="c" style="display:none;">
<p>
<code>Herror <b>tuple_string</b>(double <a href="#T"><i>T</i></a>, const char* <a href="#Format"><i>Format</i></a>, char* <a href="#String"><i>String</i></a>)</code></p>
<p>
<code>Herror <b>T_tuple_string</b>(const Htuple <a href="#T"><i>T</i></a>, const Htuple <a href="#Format"><i>Format</i></a>, Htuple* <a href="#String"><i>String</i></a>)</code></p>
</div>
<div data-if="cpp" style="display:none;">
<p>
<code>void <b>TupleString</b>(const HTuple&amp; <a href="#T"><i>T</i></a>, const HTuple&amp; <a href="#Format"><i>Format</i></a>, HTuple* <a href="#String"><i>String</i></a>)</code></p>
<p>
<code><a href="HTuple.html">HTuple</a> <a href="HTuple.html">HTuple</a>::<b>TupleString</b>(const HTuple&amp; <a href="#Format"><i>Format</i></a>) const</code></p>
</div>
<div data-if="com" style="display:none;"></div>
<div data-if="dotnet" style="display:none;">
<p>
<code>static void <a href="HOperatorSet.html">HOperatorSet</a>.<b>TupleString</b>(<a href="HTuple.html">HTuple</a> <a href="#T"><i>t</i></a>, <a href="HTuple.html">HTuple</a> <a href="#Format"><i>format</i></a>, out <a href="HTuple.html">HTuple</a> <a href="#String"><i>stringVal</i></a>)</code></p>
<p>
<code><a href="HTuple.html">HTuple</a> <a href="HTuple.html">HTuple</a>.<b>TupleString</b>(<a href="HTuple.html">HTuple</a> <a href="#Format"><i>format</i></a>)</code></p>
</div>
<div data-if="python" style="display:none;">
<p>
<code>def <b>tuple_string</b>(<a href="#T"><i>t</i></a>: MaybeSequence[Union[float, int, str]], <a href="#Format"><i>format</i></a>: str) -&gt; Sequence[str]</code></p>
<p>
<code>def <b>tuple_string_s</b>(<a href="#T"><i>t</i></a>: MaybeSequence[Union[float, int, str]], <a href="#Format"><i>format</i></a>: str) -&gt; str</code></p>
</div>
<h2 id="sec_description">描述</h2>
<p><code><span data-if="hdevelop" style="display:inline">tuple_string</span><span data-if="c" style="display:none">tuple_string</span><span data-if="cpp" style="display:none">TupleString</span><span data-if="com" style="display:none">TupleString</span><span data-if="dotnet" style="display:none">TupleString</span><span data-if="python" style="display:none">tuple_string</span></code> converts numbers into strings or modifies strings.
该算子 has two parameters: <a href="#T"><i><code><span data-if="hdevelop" style="display:inline">T</span><span data-if="c" style="display:none">T</span><span data-if="cpp" style="display:none">T</span><span data-if="com" style="display:none">T</span><span data-if="dotnet" style="display:none">t</span><span data-if="python" style="display:none">t</span></code></i></a> is the number or string
that has to be converted.  <a href="#Format"><i><code><span data-if="hdevelop" style="display:inline">Format</span><span data-if="c" style="display:none">Format</span><span data-if="cpp" style="display:none">Format</span><span data-if="com" style="display:none">Format</span><span data-if="dotnet" style="display:none">format</span><span data-if="python" style="display:none">format</span></code></i></a> specifies the conversion.
</p>
<p>In the following, first some examples for the use of
<code><span data-if="hdevelop" style="display:inline">tuple_string</span><span data-if="c" style="display:none">tuple_string</span><span data-if="cpp" style="display:none">TupleString</span><span data-if="com" style="display:none">TupleString</span><span data-if="dotnet" style="display:none">TupleString</span><span data-if="python" style="display:none">tuple_string</span></code> are given and then, the structure of the
<a href="#Format"><i><code><span data-if="hdevelop" style="display:inline">Format</span><span data-if="c" style="display:none">Format</span><span data-if="cpp" style="display:none">Format</span><span data-if="com" style="display:none">Format</span><span data-if="dotnet" style="display:none">format</span><span data-if="python" style="display:none">format</span></code></i></a> string is explained in detail.
</p>
<p><b>Examples</b>
</p>
<p>Examples for the conversion of numbers into strings:
</p>
<div style="text-align:center"><table style="margin-left:auto;margin-right:auto" class="grid">
<col span="1">
<col span="1">
<col span="1">
<tr>
<td style="text-align:left">
<a href="#T"><i><code><span data-if="hdevelop" style="display:inline">T</span><span data-if="c" style="display:none">T</span><span data-if="cpp" style="display:none">T</span><span data-if="com" style="display:none">T</span><span data-if="dotnet" style="display:none">t</span><span data-if="python" style="display:none">t</span></code></i></a> (Input) </td>
<td style="text-align:left"> <a href="#Format"><i><code><span data-if="hdevelop" style="display:inline">Format</span><span data-if="c" style="display:none">Format</span><span data-if="cpp" style="display:none">Format</span><span data-if="com" style="display:none">Format</span><span data-if="dotnet" style="display:none">format</span><span data-if="python" style="display:none">format</span></code></i></a> (Input) </td>
<td style="text-align:left"> <a href="#String"><i><code><span data-if="hdevelop" style="display:inline">String</span><span data-if="c" style="display:none">String</span><span data-if="cpp" style="display:none">String</span><span data-if="com" style="display:none">String</span><span data-if="dotnet" style="display:none">stringVal</span><span data-if="python" style="display:none">string</span></code></i></a> (Output) </td>
</tr>
<tr>
<td style="text-align:left">
23                 </td>
<td style="text-align:left"> '10.2f'                 </td>
<td style="text-align:left"> '         23.00'         </td>
</tr>
<tr>
<td style="text-align:left">
23                 </td>
<td style="text-align:left"> '-10.2f'                </td>
<td style="text-align:left"> '23.00         '         </td>
</tr>
<tr>
<td style="text-align:left">
4                  </td>
<td style="text-align:left"> '.7f'                   </td>
<td style="text-align:left"> '4.0000000'              </td>
</tr>
<tr>
<td style="text-align:left">
1234.56789         </td>
<td style="text-align:left"> '+10.3f'                </td>
<td style="text-align:left"> ' +1234.568'             </td>
</tr>
<tr>
<td style="text-align:left">
255                </td>
<td style="text-align:left"> 'x'                     </td>
<td style="text-align:left"> 'ff'                     </td>
</tr>
<tr>
<td style="text-align:left">
255                </td>
<td style="text-align:left"> 'X'                     </td>
<td style="text-align:left"> 'FF'                     </td>
</tr>
<tr>
<td style="text-align:left">
0xff               </td>
<td style="text-align:left"> '.5d'                   </td>
<td style="text-align:left"> '00255'
</td>
</tr>
</table></div>
<p>Examples for the modification of strings:
</p>
<div style="text-align:center"><table style="margin-left:auto;margin-right:auto" class="grid">
<col span="1">
<col span="1">
<col span="1">
<tr>
<td style="text-align:left">
<a href="#T"><i><code><span data-if="hdevelop" style="display:inline">T</span><span data-if="c" style="display:none">T</span><span data-if="cpp" style="display:none">T</span><span data-if="com" style="display:none">T</span><span data-if="dotnet" style="display:none">t</span><span data-if="python" style="display:none">t</span></code></i></a> (Input) </td>
<td style="text-align:left"> <a href="#Format"><i><code><span data-if="hdevelop" style="display:inline">Format</span><span data-if="c" style="display:none">Format</span><span data-if="cpp" style="display:none">Format</span><span data-if="com" style="display:none">Format</span><span data-if="dotnet" style="display:none">format</span><span data-if="python" style="display:none">format</span></code></i></a> (Input) </td>
<td style="text-align:left"> <a href="#String"><i><code><span data-if="hdevelop" style="display:inline">String</span><span data-if="c" style="display:none">String</span><span data-if="cpp" style="display:none">String</span><span data-if="com" style="display:none">String</span><span data-if="dotnet" style="display:none">stringVal</span><span data-if="python" style="display:none">string</span></code></i></a> (Output) </td>
</tr>
<tr>
<td style="text-align:left">
'total'            </td>
<td style="text-align:left"> '10s'                   </td>
<td style="text-align:left"> '       total'           </td>
</tr>
<tr>
<td style="text-align:left">
'total'            </td>
<td style="text-align:left"> '-10s'                  </td>
<td style="text-align:left"> 'total       '           </td>
</tr>
<tr>
<td style="text-align:left">
'total'            </td>
<td style="text-align:left"> '-10.3s'                </td>
<td style="text-align:left"> 'tot          '
</td>
</tr>
</table></div>
<p><b>Format string</b>
</p>
<p>The <a href="#Format"><i><code><span data-if="hdevelop" style="display:inline">Format</span><span data-if="c" style="display:none">Format</span><span data-if="cpp" style="display:none">Format</span><span data-if="com" style="display:none">Format</span><span data-if="dotnet" style="display:none">format</span><span data-if="python" style="display:none">format</span></code></i></a> string consists of the following four parts:
<span class="pre">
      &lt;flags&gt;&lt;field width&gt;.&lt;precision&gt;&lt;conversion characters&gt;
</span>
</p>
<dl class="generic">


<dt><b><code>flags</code></b></dt>
<dd>
<p>
 Zero or more flags, in any
order, which modify the meaning of the conversion specification.
Flags may consist of the following characters:
</p>
<dl class="generic">


<dt><b><code>-</code></b></dt>
<dd>
<p>
 The result of the conversion is
left justified within the field.
</p>
</dd>

<dt><b><code>+</code></b></dt>
<dd>
<p>
 The result of a signed conversion
always begins with a sign, <code>+</code> or <code>-</code>.
</p>
</dd>

<dt><b>&lt;<code>space</code>&gt;</b></dt>
<dd>
<p>
 If the first
character of a signed conversion is not a sign, a space character is
prefixed to the result. This means that if the space flag
(&lt;<code>space</code>&gt;) and <code>+</code> flag both appear,
the space flag is ignored.
</p>
</dd>

<dt><b><code>#</code></b></dt>
<dd>
<p>
 The value is to be converted to
an “alternate form”.  For <code>d</code> and <code>s</code> conversions,
this flag has no effect.  For <code>o</code> conversion (see below), it
increases the precision to force the first digit of the result to be
a zero.  For <code>x</code> or <code>X</code> conversion (see below), a non-
zero result has <code>0x</code> or <code>0X</code> prefixed to it.  For
<code>e</code>, <code>E</code>, <code>f</code>, <code>g</code>, and <code>G</code>
conversions, the result always contains a radix character, even if
no digits follow the radix character.  For <code>g</code> and <code>G</code>
conversions, trailing zeros are not removed from the result,
contrary to usual behavior.
</p>
</dd>

<dt><b><code>0</code></b></dt>
<dd>
<p>
 The value should be zero padded. For
<code>d</code>, <code>o</code>, <code>u</code>, <code>x</code>, <code>X</code>,
<code>e</code>, <code>E</code>, <code>f</code>, <code>F</code>, <code>g</code>,
and <code>G</code> conversions, the converted value
is padded on the left with zeros rather than blanks. If the <code>0</code>
and <code>-</code> flags both appear, the <code>0</code> flag is ignored.
If a precision is given with a numeric conversion (<code>d</code>,
<code>o</code>, <code>u</code>, <code>x</code>, and <code>X</code>), the <code>0</code>
flag is ignored. For other conversions, the behavior is undefined.
</p>
</dd>
</dl>

</dd>

<dt><b><code>field width</code></b></dt>
<dd>
<p>
 An optional
string of decimal digits to specify a minimum field width.  For an
output field, if the converted value has fewer characters than the
field width, it is padded on the left (or right, if the
left-adjustment flag, - has been given) to the field width.
</p>
</dd>

<dt><b><code>precision</code></b></dt>
<dd>
<p>
 The precision
specifies the minimum number of digits to appear for the <code>d</code>,
<code>o</code>, <code>x</code>, or <code>X</code> conversions (the field is
padded with leading zeros), the number of digits to appear after the
radix character for the <code>e</code> and <code>f</code> conversions, the
maximum number of significant digits for the <code>g</code> conversion,
or the maximum number of characters to be printed from a string in
<code>s</code> conversion. The precision takes the form of a period
<code>.</code> followed by a decimal digit string.  A null digit string
is treated as a zero.
</p>
</dd>

<dt><b><code>conversion characters</code></b></dt>
<dd>
<p>
 A conversion character indicates the
type of conversion to be applied:
</p>
<dl class="generic">


<dt><b><code>d,u,o,x,X</code></b></dt>
<dd>
<p>
 The integer argument
is printed in signed decimal (<code>d</code>), unsigned decimal
(<code>u</code>), unsigned octal (<code>o</code>),
or unsigned hexadecimal notation (<code>x</code> and
<code>X</code>).  The <code>x</code> conversion uses the numbers and letters
<code>0123456789abcdef</code>, and the <code>X</code> conversion uses the
numbers and letters <code>0123456789ABCDEF</code>.  The precision
component of the argument specifies the minimum number of digits to
appear.  If the value being converted can be represented in fewer
digits than the specified minimum, it is expanded with leading
zeroes.  The default precision is 1.  The result of converting a
zero value with a precision of 0 is no characters.
</p>
</dd>

<dt><b><code>f</code></b></dt>
<dd>
<p>
 The floating-point number argument
is printed in decimal notation in the style <code>[-]dddrddd</code>,
where the number of digits after the radix character, <code>r</code>, is
equal to the precision specification.  If the precision is omitted
from the argument, six digits are output; if the precision is
explicitly 0, no radix appears.
</p>
</dd>

<dt><b><code>e,E</code></b></dt>
<dd>
<p>
 The floating-point-number
argument is printed in the style <code>[-]drddde</code>pm<code>dd</code>,
where there is one digit before the radix character, and the number
of digits after it is equal to the precision.  When the precision is
missing, six digits are produced; if the precision is 0, no radix
character appears.  The <code>E</code> conversion character produces a
number with <code>E</code> introducing the exponent instead of
<code>e</code>.  The exponent always contains at least two digits.
However, if the value to be printed requires an exponent greater
than two digits, additional exponent digits are printed as
necessary.
</p>
</dd>

<dt><b><code>g,G</code></b></dt>
<dd>
<p>
 The floating-point-number
argument is printed in style <code>f</code> or <code>e</code> (or in style
<code>E</code> in the case of a <code>G</code> conversion character), with
the precision specifying the number of significant digits.  The
style used depends on the value converted; style <code>e</code> is used
only if the exponent resulting from the conversion is less than -4
or greater than or equal to the precision.  Trailing zeros are
removed from the result.  A radix character appears only if it is
followed by a digit.
</p>
</dd>

<dt><b><code>s</code></b></dt>
<dd>
<p>
 The argument is taken to be a
string, and characters from the string are printed until the end of
the string or the number of characters indicated by the precision
specification of the argument is reached.  If the precision is
omitted from the argument, it is interpreted as infinite and all
characters up to the end of the string are printed.
</p>
</dd>

<dt><b><code>b</code></b></dt>
<dd>
<p>
 Similar to the <code>s</code>
conversion specifier, except that the string can contain
backslash-escape sequences which are then converted to the
characters they represent.
</p>
</dd>
</dl>

<p>In no case does a nonexistent or insufficient field width cause
truncation of a field; if the result of a conversion is wider than
the field width, the field is simply expanded to contain the
conversion result.
</p>
</dd>
</dl>
<h3>Exception: Empty input tuple</h3>
<p>If any of the input tuples is empty, an exception is raised.
</p>
<h3>HDevelop In-line Operation</h3>
<p>HDevelop provides an in-line operation for <code><span data-if="hdevelop" style="display:inline">tuple_string</span><span data-if="c" style="display:none">tuple_string</span><span data-if="cpp" style="display:none">TupleString</span><span data-if="com" style="display:none">TupleString</span><span data-if="dotnet" style="display:none">TupleString</span><span data-if="python" style="display:none">tuple_string</span></code>,
which can be used in an expression in the following syntax:
</p>
<p><a href="../../manuals/hdevelop_users_guide/hdevelop_language_operations_string_0000.html">
<code>String := T $ Format</code>
</a>
</p>
<h2 id="sec_execution">运行信息</h2>
<ul>
  <li>Multithreading type: independent (runs in parallel even with exclusive operators).</li>
<li>多线程作用域:全局(可以从任何线程调用)。</li>
  <li>未经并行化处理。</li>
</ul>
<h2 id="sec_parameters">参数表</h2>
  <div class="par">
<div class="parhead">
<span id="T" class="parname"><b><code><span data-if="hdevelop" style="display:inline">T</span><span data-if="c" style="display:none">T</span><span data-if="cpp" style="display:none">T</span><span data-if="com" style="display:none">T</span><span data-if="dotnet" style="display:none">t</span><span data-if="python" style="display:none">t</span></code></b> (input_control)  </span><span>tuple(-array) <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">MaybeSequence[Union[float, int, str]]</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (real / </span><span data-if="hdevelop" style="display:inline">integer / </span><span data-if="hdevelop" style="display:inline">string)</span><span data-if="dotnet" style="display:none"> (<i>double</i> / </span><span data-if="dotnet" style="display:none">int / </span><span data-if="dotnet" style="display:none">long / </span><span data-if="dotnet" style="display:none">string)</span><span data-if="cpp" style="display:none"> (<i>double</i> / </span><span data-if="cpp" style="display:none">Hlong / </span><span data-if="cpp" style="display:none">HString)</span><span data-if="c" style="display:none"> (<i>double</i> / </span><span data-if="c" style="display:none">Hlong / </span><span data-if="c" style="display:none">char*)</span></span>
</div>
<p class="pardesc">Input tuple.</p>
</div>
  <div class="par">
<div class="parhead">
<span id="Format" class="parname"><b><code><span data-if="hdevelop" style="display:inline">Format</span><span data-if="c" style="display:none">Format</span><span data-if="cpp" style="display:none">Format</span><span data-if="com" style="display:none">Format</span><span data-if="dotnet" style="display:none">format</span><span data-if="python" style="display:none">format</span></code></b> (input_control)  </span><span>string <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">str</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (string)</span><span data-if="dotnet" style="display:none"> (<i>string</i>)</span><span data-if="cpp" style="display:none"> (<i>HString</i>)</span><span data-if="c" style="display:none"> (<i>char*</i>)</span></span>
</div>
<p class="pardesc">Format string.</p>
</div>
  <div class="par">
<div class="parhead">
<span id="String" class="parname"><b><code><span data-if="hdevelop" style="display:inline">String</span><span data-if="c" style="display:none">String</span><span data-if="cpp" style="display:none">String</span><span data-if="com" style="display:none">String</span><span data-if="dotnet" style="display:none">stringVal</span><span data-if="python" style="display:none">string</span></code></b> (output_control)  </span><span>string(-array) <code>→</code> <span data-if="dotnet" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="python" style="display:none">Sequence[str]</span><span data-if="cpp" style="display:none"><a href="HTuple.html">HTuple</a></span><span data-if="c" style="display:none">Htuple</span><span data-if="hdevelop" style="display:inline"> (string)</span><span data-if="dotnet" style="display:none"> (<i>string</i>)</span><span data-if="cpp" style="display:none"> (<i>HString</i>)</span><span data-if="c" style="display:none"> (<i>char*</i>)</span></span>
</div>
<p class="pardesc">Input tuple converted to strings.</p>
</div>
<h2 id="sec_example_all">例程 (HDevelop)</h2>
<pre class="example">
*
* '     23.00'
tuple_string (23, '10.2f', String)
String := 23$'10.2f'
*
* '23.00     '
tuple_string (23, '-10.2f', String)
String := 23$'-10.2f'
*
* '4.0000000'
tuple_string (4, '.7f', String)
String := 4$'.7f'
*
* ' +1234.568'
tuple_string (1234.56789, '+10.3f', String)
String := 1234.56789$'+10.3f'
*
* 'ff'
tuple_string (255, 'x', String)
String := 255$'x'
*
* 'FF'
tuple_string (255, 'X', String)
String := 255$'X'
*
* '00255'
tuple_string (0xff, '.5d', String)
String := 0xff$'.5d'
*
* '     total'
tuple_string ('total', '10s', String)
String := 'total'$'10s'
*
* 'total     '
tuple_string ('total', '-10s', String)
String := 'total'$'-10s'
*
* 'tot       '
tuple_string ('total', '-10.3s', String)
String := 'total'$'-10.3s'
</pre>
<h2 id="sec_alternatives">可替代算子</h2>
<p>
<code><a href="tuple_sub.html"><span data-if="hdevelop" style="display:inline">tuple_sub</span><span data-if="c" style="display:none">tuple_sub</span><span data-if="cpp" style="display:none">TupleSub</span><span data-if="com" style="display:none">TupleSub</span><span data-if="dotnet" style="display:none">TupleSub</span><span data-if="python" style="display:none">tuple_sub</span></a></code>
</p>
<h2 id="sec_module">模块</h2>
<p>
Foundation</p>
<!--OP_REF_FOOTER_START-->
<hr>
<div class="indexlink">
<a href="index_classes.html"><span data-if="dotnet" style="display:none;">类别</span><span data-if="cpp" style="display:none;">类别</span></a><span data-if="dotnet" style="display:none;"> | </span><span data-if="cpp" style="display:none;"> | </span><a href="index_by_name.html">算子列表</a>
</div>
<div class="footer">
<div class="copyright">HALCON算子参考手册 Copyright © 2015-2023 51Halcon</div>
</div>
</div>
</body>
</html>
